Scoped<T> was allocating on the heap for internal ref-count increments/decrements because each lifetime change created a new ReferenceCount<T> instance. This change keeps only the lifetime object allocated while moving the scope’s ref-count state to an allocation-free atomic implementation.

• Allocation-free scoped ref counting

  • Replace Scoped<T>'s copy-on-write ReferenceCount<T> updates with a single atomic state field.
  • Encode disposed state and active reference count in that field so lifetime acquisition/release no longer allocates.
  • Preserve existing semantics for double-dispose, disposal races, and “dispose only after last lifetime” behavior.

• Lifetime<T> support for scoped fast path

  • Extend Lifetime<T> internals to support a direct releaser callback path for Scoped<T>.
  • Keep the existing ReferenceCount<T>-based constructor for other callers unchanged.

• Compatibility / edge cases

  • Preserve behavior for disposed default scopes created by the atomic scoped factory path.
  • Keep the public API surface additive-neutral; the change is internal to the implementation.

• Regression coverage

  • Add a scoped allocation regression test that asserts repeated CreateLifetime() calls do not reintroduce heap allocation for internal ref counting.

var scope = new Scoped<Disposable>(new Disposable());

using var lifetime1 = scope.CreateLifetime();
using var lifetime2 = scope.CreateLifetime();

// lifetime creation still works the same for callers,
// but internal ref-count updates no longer allocate.